home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / tripong.swf / scripts / frame_3 / PlaceObject2_28_5 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Encoding:
Text File  |  2007-04-23  |  9.1 KB  |  310 lines
  1. onClipEvent(enterFrame){
  2.    createEmptyMovieClip("fill",10000);
  3.    fill.lineStyle(1.5,16777215);
  4.    fill.moveTo(xp[0],yp[0]);
  5.    fill.beginFill(16777215,30);
  6.    fill.lineTo(xp[1],yp[1]);
  7.    fill.lineTo(xp[2],yp[2]);
  8.    fill.endFill();
  9.    fill.moveTo(xp[3],yp[3]);
  10.    fill.lineTo(xp[4],yp[4]);
  11.    fill.moveTo(xp[5],yp[5]);
  12.    fill.lineTo(xp[6],yp[6]);
  13.    xpos = (xp[0] + xp[1] + xp[2]) / 3;
  14.    ypos = (yp[0] + yp[1] + yp[2]) / 3;
  15.    if(xpos < 25 or xpos > 525)
  16.    {
  17.       stex = "k6.mp3";
  18.       xp[0] = 275 + Math.random() - 0.5;
  19.       yp[0] = 200 + Math.random() - 0.5;
  20.       xp[1] = 250;
  21.       yp[1] = 250;
  22.       xp[2] = 300;
  23.       yp[2] = 250;
  24.       xbew[0] = 0;
  25.       ybew[0] = 0;
  26.       xbew[1] = 0;
  27.       ybew[1] = 0;
  28.       xbew[2] = 0;
  29.       ybew[2] = 0;
  30.       if(xpos < 275)
  31.       {
  32.          _parent.tex1 = _parent.tex1 + 1;
  33.          if(_parent.tex1 >= _parent.mp)
  34.          {
  35.             _parent.tex1 = "-1-";
  36.             prevf = true;
  37.             stex = "k12.mp3";
  38.          }
  39.       }
  40.       else
  41.       {
  42.          _parent.tex = _parent.tex + 1;
  43.          if(_parent.tex >= _parent.mp)
  44.          {
  45.             _parent.tex1 = "-2-";
  46.             prevf = true;
  47.             stex = "k12.mp3";
  48.          }
  49.       }
  50.       if(_parent.soundon)
  51.       {
  52.          _parent.sound1 = new Sound(this);
  53.          _parent.sound1.setVolume(100);
  54.          _parent.sound1.attachSound(stex,true);
  55.          _parent.sound1.start(0,1);
  56.       }
  57.       if(prevf)
  58.       {
  59.          _parent.prevFrame();
  60.       }
  61.       xpos = xp[0];
  62.    }
  63.    if(xpos > 450)
  64.    {
  65.       md2 = 0;
  66.    }
  67.    else
  68.    {
  69.       md2 = 1;
  70.    }
  71.    ypos2 = (ypos2 * 9 + Math.max(70,Math.min(330,ypos))) / 10;
  72.    xbew[5] += (450 + 50 * md2 - xp[5] - xbew[5]) * 0.35;
  73.    xbew[6] += (450 + 50 * md2 - xp[6] - xbew[6]) * 0.35;
  74.    ybew[5] += (ypos2 + 50 - yp[5] - ybew[5]) * 0.35;
  75.    ybew[6] += (ypos2 - 50 - yp[6] - ybew[6]) * 0.35;
  76.    if(xpos < 275)
  77.    {
  78.       xpos = -0.05;
  79.    }
  80.    else
  81.    {
  82.       xpos = 0.05;
  83.    }
  84.    ypos = 0;
  85.    e = 0;
  86.    while(e < 3)
  87.    {
  88.       xbew[e] += xpos;
  89.       ybew[e] += ypos;
  90.       e++;
  91.    }
  92.    ymouse = Math.max(70,Math.min(330,_ymouse));
  93.    xbew[3] += (50 + 50 * md - xp[3] - xbew[3]) * 0.35;
  94.    xbew[4] += (50 + 50 * md - xp[4] - xbew[4]) * 0.35;
  95.    ybew[3] += (ymouse + 50 - yp[3] - ybew[3]) * 0.35;
  96.    ybew[4] += (ymouse - 50 - yp[4] - ybew[4]) * 0.35;
  97.    maxp = 0;
  98.    e = 0;
  99.    while(e < ballz)
  100.    {
  101.       ybew[e] += (Math.random() * 0.1 - 0.05) * 0.03;
  102.       xbew[e] += (Math.random() * 0.1 - 0.05) * 0.03;
  103.       e++;
  104.    }
  105.    done = 0.01;
  106.    while(done < 1)
  107.    {
  108.       t3 = 1 - done;
  109.       e = 0;
  110.       while(e < ballz)
  111.       {
  112.          a = 0;
  113.          while(a < strichz)
  114.          {
  115.             if(ep[a] != e && sp[a] != e && Math.abs(xp[e] - (xp[ep[a]] + xp[sp[a]]) / 2) - Math.abs(xp[sp[a]] - xp[ep[a]]) / 2 < (Math.abs(xbew[e]) + Math.abs(xbew[ep[a]]) + Math.abs(xbew[sp[a]])) * 2 && Math.abs(yp[e] - (yp[ep[a]] + yp[sp[a]]) / 2) - Math.abs(yp[sp[a]] - yp[ep[a]]) / 2 < (Math.abs(ybew[e]) + Math.abs(ybew[ep[a]]) + Math.abs(ybew[sp[a]])) * 2)
  116.             {
  117.                t = 100;
  118.                tak = "no";
  119.                alpha = xbew[ep[a]] * ybew[sp[a]] - ybew[e] * xbew[ep[a]] - xbew[e] * ybew[sp[a]] - ybew[ep[a]] * xbew[sp[a]] + ybew[ep[a]] * xbew[e] + ybew[e] * xbew[sp[a]];
  120.                beta = xp[ep[a]] * ybew[sp[a]] - xp[ep[a]] * ybew[e] + yp[sp[a]] * xbew[ep[a]] - yp[e] * xbew[ep[a]] - xp[e] * ybew[sp[a]] + xp[e] * ybew[e] - xbew[e] * yp[sp[a]] - yp[ep[a]] * xbew[sp[a]] + yp[ep[a]] * xbew[e] + yp[e] * xbew[sp[a]] - xp[sp[a]] * ybew[ep[a]] + xp[e] * ybew[ep[a]] + xp[sp[a]] * ybew[e] - xp[e] * ybew[e];
  121.                lambda = yp[sp[a]] * xp[ep[a]] - yp[e] * xp[ep[a]] - xp[e] * yp[sp[a]] + yp[e] * xp[e] - yp[ep[a]] * xp[sp[a]] + yp[ep[a]] * xp[e] + yp[e] * xp[sp[a]] - yp[e] * xp[e];
  122.                lambda = Math.sqrt(beta * beta - 4 * alpha * lambda);
  123.                t1 = (- beta + lambda) / (2 * alpha);
  124.                t2 = (- beta - lambda) / (2 * alpha);
  125.                alpha = (xp[sp[a]] - xp[e] + (xbew[sp[a]] - xbew[e]) * t2) / (xp[ep[a]] - xp[e] + (xbew[ep[a]] - xbew[e]) * t2);
  126.                lambda = (xp[sp[a]] - xp[e] + (xbew[sp[a]] - xbew[e]) * t1) / (xp[ep[a]] - xp[e] + (xbew[ep[a]] - xbew[e]) * t1);
  127.                if(t1 < t2 && t1 > 0 && lambda < 0)
  128.                {
  129.                   tak = "t1";
  130.                   t = t1;
  131.                   beta = lambda;
  132.                }
  133.                else if(t2 > 0 && alpha < 0)
  134.                {
  135.                   tak = "t2";
  136.                   t = t2;
  137.                   beta = alpha;
  138.                }
  139.                if(t <= 1 - done && tak != "no")
  140.                {
  141.                   t3 = Math.min(t,t3);
  142.                   if(t == t3)
  143.                   {
  144.                      the_e = e;
  145.                      the_a = a;
  146.                      the_beta = beta;
  147.                   }
  148.                }
  149.             }
  150.             a++;
  151.          }
  152.          e++;
  153.       }
  154.       if(t3 != 1 - done)
  155.       {
  156.          e = 0;
  157.          while(e < ballz)
  158.          {
  159.             xp[e] += xbew[e] * (t3 * 0.99);
  160.             yp[e] += ybew[e] * (t3 * 0.99);
  161.             e++;
  162.          }
  163.          e = the_e;
  164.          a = the_a;
  165.          beta = the_beta;
  166.          beta = 1 - 1 / (1 - beta);
  167.          xbewenf = xbew[e] - xbew[sp[a]] * (1 - beta) - xbew[ep[a]] * beta;
  168.          ybewenf = ybew[e] - ybew[sp[a]] * (1 - beta) - ybew[ep[a]] * beta;
  169.          xenf = xp[sp[a]] - xp[ep[a]];
  170.          yenf = yp[sp[a]] - yp[ep[a]];
  171.          p = Math.sqrt(ybewenf * ybewenf + xbewenf * xbewenf);
  172.          enf = Math.sqrt(yenf * yenf + xenf * xenf);
  173.          w = xenf / enf;
  174.          if(- yenf > 0)
  175.          {
  176.             lambda = 180 + Math.asin(w) / 0.017453277777777776;
  177.          }
  178.          else
  179.          {
  180.             lambda = - Math.asin(w) / 0.017453277777777776;
  181.          }
  182.          w = ybewenf / p;
  183.          if(xbewenf > 0)
  184.          {
  185.             alpha = 180 + Math.asin(w) / 0.017453277777777776;
  186.          }
  187.          else
  188.          {
  189.             alpha = - Math.asin(w) / 0.017453277777777776;
  190.          }
  191.          alpha -= lambda;
  192.          alpha = Math.abs(alpha);
  193.          if(Math.abs(alpha) > 180)
  194.          {
  195.             alpha -= 360;
  196.          }
  197.          if(Math.abs(alpha) > 90)
  198.          {
  199.             xenf = - xenf;
  200.             yenf = - yenf;
  201.          }
  202.          xbewenf = (- yenf) / enf * p;
  203.          ybewenf = xenf / enf * p;
  204.          beta = 1 - beta;
  205.          xbew[e] -= xbewenf * op;
  206.          ybew[e] -= ybewenf * op;
  207.          xbew[sp[a]] += xbewenf * beta * op;
  208.          ybew[sp[a]] += ybewenf * beta * op;
  209.          xbew[ep[a]] += xbewenf * (1 - beta) * op;
  210.          ybew[ep[a]] += ybewenf * (1 - beta) * op;
  211.          xbew[e] *= op2;
  212.          ybew[e] *= op2;
  213.          xbew[sp[a]] *= op2;
  214.          ybew[sp[a]] *= op2;
  215.          xbew[ep[a]] *= op2;
  216.          ybew[ep[a]] *= op2;
  217.          if(_parent.soundon)
  218.          {
  219.             _parent.quietsch.play();
  220.          }
  221.       }
  222.       else
  223.       {
  224.          e = 0;
  225.          while(e < ballz)
  226.          {
  227.             xp[e] += xbew[e] * (1 - done);
  228.             yp[e] += ybew[e] * (1 - done);
  229.             e++;
  230.          }
  231.       }
  232.       done += t3;
  233.    }
  234.    e = 0;
  235.    while(e < ballz)
  236.    {
  237.       if(xp[e] > 550)
  238.       {
  239.          back = (xp[e] - 550) / xbew[e];
  240.          xp[e] -= xbew[e] * back;
  241.          yp[e] -= ybew[e] * back * 0.5;
  242.          xbew[e] *= - rob;
  243.          ybew[e] *= rob;
  244.       }
  245.       if(xp[e] < 0)
  246.       {
  247.          back = xp[e] / xbew[e];
  248.          xp[e] -= xbew[e] * back;
  249.          yp[e] -= ybew[e] * back * 0.5;
  250.          xbew[e] *= - rob;
  251.          ybew[e] *= rob;
  252.       }
  253.       if(yp[e] > 400)
  254.       {
  255.          back = (yp[e] - 400) / ybew[e];
  256.          xp[e] -= xbew[e] * back * 0.5;
  257.          yp[e] -= ybew[e] * back;
  258.          ybew[e] *= - rob;
  259.          xbew[e] *= rob;
  260.       }
  261.       if(yp[e] < 0)
  262.       {
  263.          back = yp[e] / ybew[e];
  264.          xp[e] -= xbew[e] * back * 0.5;
  265.          yp[e] -= ybew[e] * back;
  266.          ybew[e] *= - rob;
  267.          xbew[e] *= rob;
  268.       }
  269.       yb[e] = ybew[e];
  270.       xb[e] = xbew[e];
  271.       e++;
  272.    }
  273.    a = 3;
  274.    while(a < 6)
  275.    {
  276.       ber = schwabbel / the_count[ep[a]];
  277.       ber1 = schwabbel / the_count[sp[a]];
  278.       yenf = yp[sp[a]] + yb[sp[a]] * ber1 - yp[ep[a]] - yb[ep[a]] * ber;
  279.       xenf = xp[sp[a]] + xb[sp[a]] * ber1 - xp[ep[a]] - xb[ep[a]] * ber;
  280.       enf = Math.sqrt(yenf * yenf + xenf * xenf);
  281.       enfspeed = slang2[a] - enf;
  282.       if(enf == 0)
  283.       {
  284.          p = spower / 5;
  285.          xenf = 1;
  286.          enf = 1;
  287.       }
  288.       else
  289.       {
  290.          p = (- (slang[a] - enf)) * (0.4 / schwabbel);
  291.          if(Math.abs(p) > 5)
  292.          {
  293.             p *= 2;
  294.          }
  295.          if(p != 0)
  296.          {
  297.             p = Math.min(Math.abs(p),spower / 5) * Math.abs(p) / p;
  298.          }
  299.       }
  300.       maxp += Math.abs(p);
  301.       verh = sizor[ep[a]] / sizor[sp[a]];
  302.       ybew[ep[a]] += yenf / enf * p / verh;
  303.       xbew[ep[a]] += xenf / enf * p / verh;
  304.       xbew[sp[a]] -= xenf / enf * p * verh;
  305.       ybew[sp[a]] -= yenf / enf * p * verh;
  306.       slang2[a] = Math.round(enf * 10);
  307.       a++;
  308.    }
  309. }
  310.